home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cpp_libs / linklist / source.lha / patch1 < prev    next >
Text File  |  1993-08-08  |  50KB  |  2,152 lines
  1. *** ../CHANGES    Wed May 19 15:57:55 1993
  2. --- CHANGES    Wed May 19 15:39:41 1993
  3. ***************
  4. *** 1,5 ****
  5. ! Most important changes from version 0.7 to version 0.8 :
  6.   
  7.   -    Routine lIndxNode is renamed to lGetIndxNode.
  8.   
  9.   -    Routine lFlagNode is renamed to lFndFlagNode.
  10. --- 1,16 ----
  11. ! Most important changes from version 0.8 to version 0.9 (May 1993) :
  12.   
  13. + -    Bug solved in the heap sorting algorithm.
  14. + 
  15. + -    Ported to Amiga by James Diffendaffer.
  16. + 
  17. + -    Some additional porting solutions for Borland and other MSDOS C
  18. +     compilers by Shane Brath).
  19. + 
  20. + --------------------------------------------------------------------------------
  21. + 
  22. + Most important changes from version 0.7 to version 0.8 (March 1993) :
  23. + 
  24.   -    Routine lIndxNode is renamed to lGetIndxNode.
  25.   
  26.   -    Routine lFlagNode is renamed to lFndFlagNode.
  27. ***************
  28. *** 10,12 ****
  29. --- 21,67 ----
  30.       lSort.
  31.   
  32.   -    Defines are made more specific; FIRST is renamed to lFIRST, etc.
  33. + 
  34. + --------------------------------------------------------------------------------
  35. + 
  36. + Most important changes from version 0.6 to version 0.7 (March 1992) :
  37. + 
  38. + -    Ported to Macintosh by Vincent van Gentevoort.
  39. + 
  40. + -    New routine 'lFlagNode'.
  41. + 
  42. + --------------------------------------------------------------------------------
  43. + 
  44. + Most important changes from version 0.5 to version 0.6 (December 1991) :
  45. + 
  46. + -    Ported to VAX/VMS by Anita Eijs & Rene Balkenende.
  47. + 
  48. + --------------------------------------------------------------------------------
  49. + 
  50. + Most important changes from version 0.4 to version 0.5  (February 1991) :
  51. + 
  52. + -    Return type for each routine.
  53. + 
  54. + --------------------------------------------------------------------------------
  55. + 
  56. + Most important changes from version 0.3 to version 0.4 (November 1990) :
  57. + 
  58. + -    New routines 'lDump' and 'lUndump'.
  59. + 
  60. + --------------------------------------------------------------------------------
  61. + 
  62. + Most important changes from version 0.2 to version 0.3 (September 1990) :
  63. + 
  64. + -    New routine 'lError'.
  65. + 
  66. + --------------------------------------------------------------------------------
  67. + 
  68. + Most important changes from version 0.1 to version 0.2 (April 1990) :
  69. + 
  70. + -    New routine 'lIndxNode'.
  71. + 
  72. + --------------------------------------------------------------------------------
  73. + 
  74. + Version 0.1 (May 1989) :
  75. + 
  76. + -    Created by Anita Eijs, TNO-BOUW, BouwInformatica.
  77. *** ../README    Mon May  3 12:58:56 1993
  78. --- README    Tue May 25 15:23:21 1993
  79. ***************
  80. *** 2,8 ****
  81.                   ===================
  82.   
  83.   
  84. ! The distribution of the Generic Linked List package (Version 0.8, May 1993)
  85.   includes the following files:
  86.   
  87.       Doc/Intro.3        - [nt]roff manual pages
  88. --- 2,8 ----
  89.                   ===================
  90.   
  91.   
  92. ! The distribution of the Generic Linked List package (Version 0.9, May 1993)
  93.   includes the following files:
  94.   
  95.       Doc/Intro.3        - [nt]roff manual pages
  96. ***************
  97. *** 26,31 ****
  98. --- 26,34 ----
  99.       Doc/lUpdNode.3
  100.       Makefile        - Berkeley or System V Makefile
  101.       Makefile.BCC        - Borland C++ v3.1 Makefile
  102. +     ReadMe.BCC        - some additional info about Borland port
  103. +     Makefile.Amiga        - Amiga SAS C 6.0 Makefile
  104. +     ReadMe.Amiga        - some additional info about Amiga port
  105.       README            - this file !
  106.       CHANGES            - list of changes
  107.       Tools_makerule        - make rules for Makefile
  108. ***************
  109. *** 43,51 ****
  110.   
  111.   2)    Check the environment settings (RANLIB) in the Tools_makerule.
  112.   
  113. ! 3)    Enter 'make newlib' at the UNIX prompt.
  114.   
  115. ! 4)    Enter 'make test' or 'make example' to create the executable of
  116.       the program 'example' at the UNIX prompt.
  117.   
  118.   
  119. --- 46,56 ----
  120.   
  121.   2)    Check the environment settings (RANLIB) in the Tools_makerule.
  122.   
  123. ! 3)    Be sure that the LIB-directory is created.
  124.   
  125. ! 4)    Enter 'make newlib' at the UNIX prompt.
  126. ! 
  127. ! 5)    Enter 'make test' or 'make example' to create the executable of
  128.       the program 'example' at the UNIX prompt.
  129.   
  130.   
  131. ***************
  132. *** 55,63 ****
  133.   
  134.   
  135.   The Generic Linked List is in the public domain. It is available at our FTP
  136. ! archive (ftp.tno.nl or hermes.bouw.tno.nl), just retrieve te files :
  137. !     /pub/TNO/BOUW/Bouwinf/linkedlist_0.8.README
  138. !     /pub/TNO/BOUW/Bouwinf/linkedlist_0.8.shar
  139.   
  140.   
  141.   If you have any comments, suggestions, or find any bugs, or make any changes
  142. --- 60,68 ----
  143.   
  144.   
  145.   The Generic Linked List is in the public domain. It is available at our FTP
  146. ! archive (ftp.tno.nl or hermes.bouw.tno.nl), just retrieve the files :
  147. !     /pub/TNO/BOUW/Bouwinf/linkedlist_0.9.README
  148. !     /pub/TNO/BOUW/Bouwinf/linkedlist_0.9.shar
  149.   
  150.   
  151.   If you have any comments, suggestions, or find any bugs, or make any changes
  152. ***************
  153. *** 69,72 ****
  154.   P.O. Box 49
  155.   2600 AA Delft
  156.   The Netherlands
  157. ! FAX : +31 15 843990
  158. --- 74,77 ----
  159.   P.O. Box 49
  160.   2600 AA Delft
  161.   The Netherlands
  162. ! FAX : +31 15 122182
  163. *** ../example.c    Fri Feb 26 09:04:13 1993
  164. --- example.c    Fri May 21 09:58:14 1993
  165. ***************
  166. *** 1,3 ****
  167. --- 1,7 ----
  168. + #ifdef    AMIGA
  169. + #include        <string.h>
  170. + #endif
  171. + 
  172.   #include        <stdio.h>
  173.   #include        "list.h"
  174.   
  175. ***************
  176. *** 8,16 ****
  177.   } Rapport;
  178.   int    rapSz = sizeof(Rapport);
  179.   
  180.   static void    insRap(), prRapAll(), prRap();
  181. ! static int        search(), compare();
  182.   
  183.   main()
  184.   {
  185.       int            id, code, search_date;
  186. --- 12,30 ----
  187.   } Rapport;
  188.   int    rapSz = sizeof(Rapport);
  189.   
  190. + #ifdef ANSI
  191. + static void    insRap(int id, int where, int flag, char *title, char *author,
  192. +                 int date);
  193. + static void    prRapAll(int id);
  194. + static void    prRap(int code, Rapport *rpprt);
  195. + static int    search(int *date, Rapport *rpprt);
  196. + static int    compare(Rapport *data1, Rapport *data2);
  197. + #else
  198.   static void    insRap(), prRapAll(), prRap();
  199. ! static int    search(), compare();
  200. ! #endif
  201.   
  202. + int
  203.   main()
  204.   {
  205.       int            id, code, search_date;
  206. ***************
  207. *** 82,89 ****
  208.   
  209.   static void
  210.   insRap(id, where, flag, title, author, date)
  211. ! int    id, where, flag, date;
  212. ! char    *title, *author;
  213.   {
  214.       int        code;
  215.       Rapport    rap;
  216. --- 96,103 ----
  217.   
  218.   static void
  219.   insRap(id, where, flag, title, author, date)
  220. ! int        id, where, flag, date;
  221. ! char        *title, *author;
  222.   {
  223.       int        code;
  224.       Rapport    rap;
  225. *** ../list.c    Mon May  3 11:08:59 1993
  226. --- list.c    Wed May 19 16:38:34 1993
  227. ***************
  228. *** 1,3 ****
  229. --- 1,6 ----
  230. + #pragma option -ml -v -vi- -w-ret -w-nci -w-inl -wamp -w-par -w-cpt -w-dup -w-pia -w-ill -w-sus -wstv -w-ext -w-ias -w-ibc -w-pre -w-nst -A -G -O2 -w-sus -w-aus -w-par -w-pro -w-rvl
  231. + /* line at the top added for Borland or other MSDOS C compilers */
  232. + 
  233.   /*
  234.   **    Anita Eijs    TNO-BOUW, BouwInformatica    May 1989
  235.   **
  236. ***************
  237. *** 41,72 ****
  238.   **    ***** Version 0.8, May 1993 *****
  239.   */
  240.   
  241. ! #ifdef MAC
  242. ! #define    MAC_OR_VAXC
  243.   #endif
  244. ! #ifdef VAXC
  245. ! #define    MAC_OR_VAXC
  246. ! #define    MSDOS_OR_VAXC
  247.   #endif
  248.   #ifdef MSDOS
  249. ! #define    MSDOS_OR_VAXC
  250.   #endif
  251.   
  252.   #ifdef MAC
  253.   #include    <unix.h>    /* open, creat, write, read, close */
  254.   #include    <stddef.h>    /* sizeof */
  255.   #endif
  256.   
  257. ! #ifdef MAC_OR_VAXC
  258.   #include    <stdlib.h>
  259. ! #else
  260. ! #include    <malloc.h>
  261.   #endif
  262.   
  263. - #ifdef MSDOS
  264. - #include    <io.h>    /* open, creat, write, read, close */
  265. - #endif
  266. - 
  267.   #include    <stdio.h>
  268.   #include    "list.h"
  269.   
  270. --- 44,84 ----
  271.   **    ***** Version 0.8, May 1993 *****
  272.   */
  273.   
  274. ! #ifdef __MSDOS__
  275. ! #define    MSDOS
  276. ! #define    ANSI
  277.   #endif
  278. ! 
  279. ! #ifdef UNIX
  280. ! #include    <malloc.h>
  281.   #endif
  282. + 
  283.   #ifdef MSDOS
  284. ! #include    <malloc.h>
  285. ! #include    <io.h>        /* open, creat, write, read, close */
  286. !     /* added for Borland or other MSDOS C compilers */
  287. ! #include    <stdlib.h>
  288. ! #include    <fcntl.h>
  289. ! #include    <sys\types.h>
  290. ! #include    <sys\stat.h>
  291. ! #include    <string.h>
  292.   #endif
  293.   
  294. + #ifdef VAXC
  295. + #include    <stdlib.h>
  296. + #endif
  297. + 
  298.   #ifdef MAC
  299.   #include    <unix.h>    /* open, creat, write, read, close */
  300.   #include    <stddef.h>    /* sizeof */
  301. + #include    <stdlib.h>
  302.   #endif
  303.   
  304. ! #ifdef AMIGA
  305.   #include    <stdlib.h>
  306. ! #include    <fcntl.h>    /* open, creat, write, read, close */
  307.   #endif
  308.   
  309.   #include    <stdio.h>
  310.   #include    "list.h"
  311.   
  312. ***************
  313. *** 98,106 ****
  314.           while (i--) *to++ = *frm++; \
  315.       }
  316.   
  317. ! #define    BIN_WRITE    1    /* necessary for binary file access */
  318.   #define    BIN_READ    0
  319.   #define    PMODE        0666
  320.   
  321.   /* -------------------------------------------------------------------------- */
  322.   
  323. --- 110,125 ----
  324.           while (i--) *to++ = *frm++; \
  325.       }
  326.   
  327. !     /* necessary for binary file access */
  328. ! #ifdef MSDOS
  329. ! #define    BIN_WRITE    O_WRONLY|O_BINARY
  330. ! #define    BIN_READ    O_RDONLY|O_BINARY
  331. ! #define    PMODE        S_IREAD
  332. ! #else
  333. ! #define    BIN_WRITE    1
  334.   #define    BIN_READ    0
  335.   #define    PMODE        0666
  336. + #endif
  337.   
  338.   /* -------------------------------------------------------------------------- */
  339.   
  340. ***************
  341. *** 148,154 ****
  342.   static void    lError(char *str, int code, int int1, int int2, char *str1);
  343.   static int    setWhchNode(int id, int which, char *fname);
  344.   static int    setIndxNode(int id, int index, char *fname);
  345. ! static int    partition(NodePtr *array, int order, Func func, int lb, int ub,
  346.               int *pj);
  347.   static int    stack_empty(int id);
  348.   static int    intInSet(int intgr, int *set, int set_n);
  349. --- 167,173 ----
  350.   static void    lError(char *str, int code, int int1, int int2, char *str1);
  351.   static int    setWhchNode(int id, int which, char *fname);
  352.   static int    setIndxNode(int id, int index, char *fname);
  353. ! static void    partition(NodePtr *array, int order, Func func, int lb, int ub,
  354.               int *pj);
  355.   static int    stack_empty(int id);
  356.   static int    intInSet(int intgr, int *set, int set_n);
  357. ***************
  358. *** 159,165 ****
  359.   static void    lError();
  360.   static int    setWhchNode();
  361.   static int    setIndxNode();
  362. ! static int    partition();
  363.   static int    stack_empty();
  364.   static int    intInSet();
  365.   #endif
  366. --- 178,184 ----
  367.   static void    lError();
  368.   static int    setWhchNode();
  369.   static int    setIndxNode();
  370. ! static void    partition();
  371.   static int    stack_empty();
  372.   static int    intInSet();
  373.   #endif
  374. ***************
  375. *** 186,199 ****
  376.   ** Return on error:
  377.   **    lWRONG_SD, lWRONG_CC
  378.   */
  379. - #ifdef ANSI
  380.   int
  381. - lDef(int sd, int cc)
  382. - #else
  383. - int
  384.   lDef(sd, cc)
  385.   int    sd, cc;
  386. - #endif
  387.   {
  388.       ListPtr        list, new;
  389.       static int    set1[] = { lSINGLY, lDOUBLY },
  390. --- 205,213 ----
  391. ***************
  392. *** 245,258 ****
  393.   ** Return on error:
  394.   **    lUNKNOWN_ID
  395.   */
  396. - #ifdef ANSI
  397.   int
  398. - lInfo(int id, int *sd, int *cc, int *n)
  399. - #else
  400. - int
  401.   lInfo(id, sd, cc, n)
  402.   int    id, *sd, *cc, *n;
  403. - #endif
  404.   {
  405.       ListPtr    list;
  406.   
  407. --- 259,267 ----
  408. ***************
  409. *** 286,299 ****
  410.   ** Return on error:
  411.   **    lUNKNOWN_ID, lEMPTY_LIST, lWRONG_ORDER, lWRONG_THEORY
  412.   */
  413. - #ifdef ANSI
  414. - int lSort(int id, int order, int theory, Func func)
  415. - #else
  416.   int
  417.   lSort(id, order, theory, func)
  418.   int    id, order, theory;
  419.   Func    func;
  420. - #endif
  421.   {
  422.       int        node_n, i, s, f, k, where, j, cmp;
  423.       ListPtr        list;
  424. --- 295,304 ----
  425. ***************
  426. *** 320,331 ****
  427.           return(lWRONG_THEORY);
  428.       }
  429.   
  430.       node_n = list->n;
  431. !         /* allocate 1 extra so I can nave a null in it */
  432.       CALLOC(array, NodePtr, node_n+1);
  433.   
  434.       list->current = list->first;
  435. !     for (i=0; i<node_n && list->current != NULL ; i++) {
  436.           array[i] = list->current;
  437.           list->current = (list->current)->nxt;
  438.       }
  439. --- 325,340 ----
  440.           return(lWRONG_THEORY);
  441.       }
  442.   
  443. +         /* one node is already sorted */
  444. +     if (list->n == 1)
  445. +         return(lSUCCESS);
  446. + 
  447.       node_n = list->n;
  448. !         /* allocate 1 extra so I can have a null in it */
  449.       CALLOC(array, NodePtr, node_n+1);
  450.   
  451.       list->current = list->first;
  452. !     for (i=0; i < node_n && list->current != NULL; i++) {
  453.           array[i] = list->current;
  454.           list->current = (list->current)->nxt;
  455.       }
  456. ***************
  457. *** 377,386 ****
  458.                   s = -1;
  459.               else
  460.                   s = 1;
  461. !             cmp = (*func)(array[2]->data, array[1]->data);
  462. !             if (i > 2 && ((order == lASCENDING && cmp == l2LT1)
  463. !              || (order == lDESCENDING && cmp == l1LT2)))
  464. !                 s = 2;
  465.   
  466.               if (s >= 0)
  467.                   cmp = (*func)(temp->data, array[s]->data);
  468. --- 386,397 ----
  469.                   s = -1;
  470.               else
  471.                   s = 1;
  472. !             if (i > 2) {
  473. !                 cmp = (*func)(array[2]->data, array[1]->data);
  474. !                 if ((order == lASCENDING && cmp == l2LT1)
  475. !                  || (order == lDESCENDING && cmp == l1LT2))
  476. !                     s = 2;
  477. !             }
  478.   
  479.               if (s >= 0)
  480.                   cmp = (*func)(temp->data, array[s]->data);
  481. ***************
  482. *** 393,399 ****
  483.                   if (s+1 <= i-1) {
  484.                       cmp = (*func)(array[s]->data,
  485.                           array[s+1]->data);
  486. !                     if (cmp < 0)
  487.                           s = s+1;
  488.                   }
  489.                   if (s > i-1)
  490. --- 404,413 ----
  491.                   if (s+1 <= i-1) {
  492.                       cmp = (*func)(array[s]->data,
  493.                           array[s+1]->data);
  494. !                     if ((order == lASCENDING
  495. !                         && cmp == l1LT2) ||
  496. !                      (order == lDESCENDING
  497. !                         && cmp == l2LT1))
  498.                           s = s+1;
  499.                   }
  500.                   if (s > i-1)
  501. ***************
  502. *** 474,480 ****
  503.       case lSELECTION: {
  504.           int    indx;
  505.   
  506. !         for (i=node_n-1; i>0 ; i--) {
  507.               temp = array[0];
  508.               indx = 0;
  509.   
  510. --- 488,494 ----
  511.       case lSELECTION: {
  512.           int    indx;
  513.   
  514. !         for (i=node_n-1; i>0; i--) {
  515.               temp = array[0];
  516.               indx = 0;
  517.   
  518. ***************
  519. *** 557,571 ****
  520.   **    header.n    number of <info>-<data>-combinations (nodes)
  521.   **    info.size    size of <data>
  522.   */
  523. - #ifdef ANSI
  524.   int
  525. - lDump(int id, char *file)
  526. - #else
  527. - int
  528.   lDump(id, file)
  529.   int    id;
  530.   char    *file;
  531. - #endif
  532.   {
  533.   #ifndef MSDOS
  534.       int    open(), creat(), write(), close();
  535. --- 571,580 ----
  536. ***************
  537. *** 622,639 ****
  538.   ** Return on error:
  539.   **    lOPEN_ERROR
  540.   */
  541. - #ifdef ANSI
  542.   int
  543. - lUndump(char *file)
  544. - #else
  545. - int
  546.   lUndump(file)
  547.   char    *file;
  548. - #endif
  549.   {
  550.   #ifndef MSDOS
  551.       int    open(), read(), close();
  552.   #endif
  553.   
  554.       int    fdDump, i, id;
  555.       Info    info;
  556. --- 631,645 ----
  557.   ** Return on error:
  558.   **    lOPEN_ERROR
  559.   */
  560.   int
  561.   lUndump(file)
  562.   char    *file;
  563.   {
  564.   #ifndef MSDOS
  565. + #ifndef AMIGA
  566.       int    open(), read(), close();
  567.   #endif
  568. + #endif
  569.   
  570.       int    fdDump, i, id;
  571.       Info    info;
  572. ***************
  573. *** 674,687 ****
  574.   ** Return on error:
  575.   **    lUNKNOWN_ID
  576.   */
  577. - #ifdef ANSI
  578.   int
  579. - lDel(int id)
  580. - #else
  581. - int
  582.   lDel(id)
  583.   int    id;
  584. - #endif
  585.   {
  586.       ListPtr    list;
  587.   
  588. --- 680,688 ----
  589. ***************
  590. *** 710,722 ****
  591.   ** Return on error:
  592.   **    lNO_LIST
  593.   */
  594. - #ifdef ANSI
  595.   int
  596. - lDelAll(void)
  597. - #else
  598. - int
  599.   lDelAll()
  600. - #endif
  601.   {
  602.       ListPtr    list, nxt;
  603.   
  604. --- 711,718 ----
  605. ***************
  606. *** 760,774 ****
  607.   ** Return on error:
  608.   **    lUNKNOWN_ID, lWRONG_WHERE
  609.   */
  610. - #ifdef ANSI
  611.   int
  612. - lInsNode(int id, int where, Byte *data, int size, int flag)
  613. - #else
  614. - int
  615.   lInsNode(id, where, data, size, flag)
  616.   int    id, where, size, flag;
  617.   Byte    *data;
  618. - #endif
  619.   {
  620.       ListPtr        list;
  621.       NodePtr        node, new;
  622. --- 756,765 ----
  623. ***************
  624. *** 892,905 ****
  625.   ** Return on error:
  626.   **    lUNKNOWN_ID, lEMPTY_LIST, lWRONG_WHICH, lEOL, lNOT_DOUBLY
  627.   */
  628. - #ifdef ANSI
  629.   int
  630. - lInfoNode(int id, int which, int *size, int *flag)
  631. - #else
  632. - int
  633.   lInfoNode(id, which, size, flag)
  634.   int    id, which, *size, *flag;
  635. - #endif
  636.   {
  637.       ListPtr    list;
  638.       int    rtrn;
  639. --- 883,891 ----
  640. ***************
  641. *** 932,946 ****
  642.   ** Return on error:
  643.   **    lUNKNOWN_ID, lEMPTY_LIST, lWRONG_WHICH, lEOL, lNOT_DOUBLY, lSIZE_NE
  644.   */
  645. - #ifdef ANSI
  646.   int
  647. - lGetNode(int id, int which, Byte *data, int size)
  648. - #else
  649. - int
  650.   lGetNode(id, which, data, size)
  651.   int    id, which, size;
  652.   Byte    *data;
  653. - #endif
  654.   {
  655.       ListPtr    list;
  656.       int    rtrn;
  657. --- 918,927 ----
  658. ***************
  659. *** 959,965 ****
  660.   
  661.       BYTE_COPY((list->current)->data, data, size);
  662.   
  663. !     if (list->current == list->first)
  664.           return(lFIRST);
  665.       else if (list->current == list->last)
  666.           return(lLAST);
  667. --- 940,953 ----
  668.   
  669.       BYTE_COPY((list->current)->data, data, size);
  670.   
  671. !     if (list->n == 1) {
  672. !         if (which == lPREVIOUS || which == lLAST)
  673. !             return(lFIRST);
  674. !         else if (which == lNEXT || which == lFIRST)
  675. !             return(lLAST);
  676. !         else
  677. !             return(lLAST);    /* which == lCURRENT */
  678. !     } else if (list->current == list->first)
  679.           return(lFIRST);
  680.       else if (list->current == list->last)
  681.           return(lLAST);
  682. ***************
  683. *** 972,978 ****
  684.   **
  685.   ** Parameters:
  686.   **    In    int    id    identifier of linked list
  687. ! **    In    int    where    from where must be searched
  688.   **    In    Func    func    function for checking the data on conditions
  689.   **    In    Byte    *ptr    data for comparison in function
  690.   **    Out    Byte    *data    data of node
  691. --- 960,967 ----
  692.   **
  693.   ** Parameters:
  694.   **    In    int    id    identifier of linked list
  695. ! **    In    int    which    from which node must be searched and in which
  696. ! **                direction
  697.   **    In    Func    func    function for checking the data on conditions
  698.   **    In    Byte    *ptr    data for comparison in function
  699.   **    Out    Byte    *data    data of node
  700. ***************
  701. *** 981,998 ****
  702.   ** Return on success:
  703.   **    lFOUND, lFIRST, lLAST, lNOT_FOUND
  704.   ** Return on error:
  705. ! **    lUNKNOWN_ID, lEMPTY_LIST, lWRONG_WHERE, lUNKNOWN_FUNC, lNOT_DOUBLY
  706.   */
  707. - #ifdef ANSI
  708.   int
  709. ! lFndNode(int id, int where, Func func, Byte *ptr, Byte *data, int size)
  710. ! #else
  711. ! int
  712. ! lFndNode(id, where, func, ptr, data, size)
  713. ! int    id, where, size;
  714.   Func    func;
  715.   Byte    *ptr, *data;
  716. - #endif
  717.   {
  718.       NodePtr        node;
  719.       ListPtr        list;
  720. --- 970,982 ----
  721.   ** Return on success:
  722.   **    lFOUND, lFIRST, lLAST, lNOT_FOUND
  723.   ** Return on error:
  724. ! **    lUNKNOWN_ID, lEMPTY_LIST, lWRONG_WHICH, lUNKNOWN_FUNC, lNOT_DOUBLY
  725.   */
  726.   int
  727. ! lFndNode(id, which, func, ptr, data, size)
  728. ! int    id, which, size;
  729.   Func    func;
  730.   Byte    *ptr, *data;
  731.   {
  732.       NodePtr        node;
  733.       ListPtr        list;
  734. ***************
  735. *** 1008,1016 ****
  736.           lError("lFndNode", lEMPTY_LIST, id, 0, NULL);
  737.           return(lEMPTY_LIST);
  738.       }
  739. !     if (intInSet(where, set, 4) != 0) {
  740. !         lError("lFndNode", lWRONG_WHERE, where, 0, NULL);
  741. !         return(lWRONG_WHERE);
  742.       }
  743.       if (func == NULL) {
  744.           lError("lFndNode", lUNKNOWN_FUNC, (int) func, 0, NULL);
  745. --- 992,1000 ----
  746.           lError("lFndNode", lEMPTY_LIST, id, 0, NULL);
  747.           return(lEMPTY_LIST);
  748.       }
  749. !     if (intInSet(which, set, 4) != 0) {
  750. !         lError("lFndNode", lWRONG_WHICH, which, 0, NULL);
  751. !         return(lWRONG_WHICH);
  752.       }
  753.       if (func == NULL) {
  754.           lError("lFndNode", lUNKNOWN_FUNC, (int) func, 0, NULL);
  755. ***************
  756. *** 1017,1024 ****
  757.           return(lUNKNOWN_FUNC);
  758.       }
  759.   
  760. !         /* set node for where searching must start */
  761. !     switch (where) {
  762.       case lFIRST:    node = list->first;    break;
  763.       case lNEXT:
  764.       case lPREVIOUS:    node = list->current;    break;
  765. --- 1001,1008 ----
  766.           return(lUNKNOWN_FUNC);
  767.       }
  768.   
  769. !         /* set node where searching must start */
  770. !     switch (which) {
  771.       case lFIRST:    node = list->first;    break;
  772.       case lNEXT:
  773.       case lPREVIOUS:    node = list->current;    break;
  774. ***************
  775. *** 1026,1037 ****
  776.       }
  777.   
  778.           /* expected data and node must have same size */
  779. !     if ((where == lFIRST || where == lLAST) && node->size == size) {
  780.           BYTE_COPY(node->data, data, size);
  781.           cmp = (*func)(ptr, data);
  782.       }
  783.   
  784. !     switch (where) {
  785.       case lFIRST:    /* search forward */
  786.       case lNEXT:
  787.           while (cmp != lFOUND && node->nxt != NULL
  788. --- 1010,1021 ----
  789.       }
  790.   
  791.           /* expected data and node must have same size */
  792. !     if ((which == lFIRST || which == lLAST) && node->size == size) {
  793.           BYTE_COPY(node->data, data, size);
  794.           cmp = (*func)(ptr, data);
  795.       }
  796.   
  797. !     switch (which) {
  798.       case lFIRST:    /* search forward */
  799.       case lNEXT:
  800.           while (cmp != lFOUND && node->nxt != NULL
  801. ***************
  802. *** 1080,1085 ****
  803. --- 1064,1071 ----
  804.   **
  805.   ** Parameters:
  806.   **    In    int    id    identifier of linked list
  807. + **    In    int    which    from which node must be searched and in which
  808. + **                direction
  809.   **    In    int    flag    flag of node which must be retrieved
  810.   **    Out    Byte    *data    data of node
  811.   **    In    int    size    size of data
  812. ***************
  813. *** 1087,1103 ****
  814.   ** Return on success:
  815.   **    lFOUND, lFIRST, lLAST, lNOT_FOUND
  816.   ** Return on error:
  817. ! **    lUNKNOWN_ID, lEMPTY_LIST, lWRONG_WHERE, lSIZE_NE
  818.   */
  819. - #ifdef ANSI
  820.   int
  821. ! lFndFlagNode(int id, int where, int flag, Byte *data, int size)
  822. ! #else
  823. ! int
  824. ! lFndFlagNode(id, where, flag, data, size)
  825. ! int    id, where, flag, size;
  826.   Byte    *data;
  827. - #endif
  828.   {
  829.       NodePtr        node;
  830.       ListPtr        list;
  831. --- 1073,1084 ----
  832.   ** Return on success:
  833.   **    lFOUND, lFIRST, lLAST, lNOT_FOUND
  834.   ** Return on error:
  835. ! **    lUNKNOWN_ID, lEMPTY_LIST, lWRONG_WHICH, lSIZE_NE
  836.   */
  837.   int
  838. ! lFndFlagNode(id, which, flag, data, size)
  839. ! int    id, which, flag, size;
  840.   Byte    *data;
  841.   {
  842.       NodePtr        node;
  843.       ListPtr        list;
  844. ***************
  845. *** 1112,1124 ****
  846.           lError("lFndFlagNode", lEMPTY_LIST, id, 0, NULL);
  847.           return(lEMPTY_LIST);
  848.       }
  849. !     if (intInSet(where, set, 4) != 0) {
  850. !         lError("lFndFlagNode", lWRONG_WHERE, where, 0, NULL);
  851. !         return(lWRONG_WHERE);
  852.       }
  853.   
  854. !         /* set node for where searching must start */
  855. !     switch (where) {
  856.       case lFIRST:
  857.           node = list->first;
  858.           break;
  859. --- 1093,1105 ----
  860.           lError("lFndFlagNode", lEMPTY_LIST, id, 0, NULL);
  861.           return(lEMPTY_LIST);
  862.       }
  863. !     if (intInSet(which, set, 4) != 0) {
  864. !         lError("lFndFlagNode", lWRONG_WHICH, which, 0, NULL);
  865. !         return(lWRONG_WHICH);
  866.       }
  867.   
  868. !         /* set node where searching must start */
  869. !     switch (which) {
  870.       case lFIRST:
  871.           node = list->first;
  872.           break;
  873. ***************
  874. *** 1138,1144 ****
  875.       }
  876.   
  877.           /* search till begin/end of list */
  878. !     switch (where) {
  879.       case lFIRST:    /* search forward */
  880.       case lNEXT:
  881.           while (node->flag != flag && node != list->last)
  882. --- 1119,1125 ----
  883.       }
  884.   
  885.           /* search till begin/end of list */
  886. !     switch (which) {
  887.       case lFIRST:    /* search forward */
  888.       case lNEXT:
  889.           while (node->flag != flag && node != list->last)
  890. ***************
  891. *** 1172,1178 ****
  892.   
  893.       BYTE_COPY((list->current)->data, data, size);
  894.   
  895. !     if (list->current == list->first)
  896.           return(lFIRST);
  897.       else if (list->current == list->last)
  898.           return(lLAST);
  899. --- 1153,1166 ----
  900.   
  901.       BYTE_COPY((list->current)->data, data, size);
  902.   
  903. !     if (list->n == 1) {
  904. !         if (which == lPREVIOUS || which == lLAST)
  905. !             return(lFIRST);
  906. !         else if (which == lNEXT || which == lFIRST)
  907. !             return(lLAST);
  908. !         else
  909. !             return(lLAST);    /* which == lCURRENT */
  910. !     } else if (list->current == list->first)
  911.           return(lFIRST);
  912.       else if (list->current == list->last)
  913.           return(lLAST);
  914. ***************
  915. *** 1181,1187 ****
  916.   }
  917.   
  918.   /*******************************************************************************
  919. ! ** Update curent node.
  920.   **
  921.   ** Parameters:
  922.   **    In    int    id    identifier of linked list
  923. --- 1169,1175 ----
  924.   }
  925.   
  926.   /*******************************************************************************
  927. ! ** Update current node.
  928.   **
  929.   ** Parameters:
  930.   **    In    int    id    identifier of linked list
  931. ***************
  932. *** 1194,1208 ****
  933.   ** Return on error:
  934.   **    lUNKNOWN_ID, lEMPTY_LIST
  935.   */
  936. - #ifdef ANSI
  937.   int
  938. - lUpdNode(int id, Byte *data, int size, int flag)
  939. - #else
  940. - int
  941.   lUpdNode(id, data, size, flag)
  942.   int    id, size, flag;
  943.   Byte    *data;
  944. - #endif
  945.   {
  946.       ListPtr    list;
  947.   
  948. --- 1182,1191 ----
  949. ***************
  950. *** 1242,1255 ****
  951.   ** Return on error:
  952.   **    lUNKNOWN_ID, lEMPTY_LIST, lWRONG_WHICH
  953.   */
  954. - #ifdef ANSI
  955.   int
  956. - lDelNode(int id, int which)
  957. - #else
  958. - int
  959.   lDelNode(id, which)
  960.   int    id, which;
  961. - #endif
  962.   {
  963.       NodePtr        node, prv, nxt;
  964.       ListPtr        list;
  965. --- 1225,1233 ----
  966. ***************
  967. *** 1355,1368 ****
  968.   ** Return on error:
  969.   **    lUNKNOWN_ID, lEMPTY_LIST, lWRONG_INDEX
  970.   */
  971. - #ifdef ANSI
  972.   int
  973. - lInfoIndxNode(int id, int index, int *size, int *flag)
  974. - #else
  975. - int
  976.   lInfoIndxNode(id, index, size, flag)
  977.   int    id, index, *size, *flag;
  978. - #endif
  979.   {
  980.       ListPtr    list;
  981.       int    rtrn;
  982. --- 1333,1341 ----
  983. ***************
  984. *** 1394,1408 ****
  985.   ** Return on error:
  986.   **    lUNKNOWN_ID, lEMPTY_LIST, lWRONG_INDEX, lSIZE_NE
  987.   */
  988. - #ifdef ANSI
  989.   int
  990. - lGetIndxNode(int id, int index, Byte *data, int size)
  991. - #else
  992. - int
  993.   lGetIndxNode(id, index, data, size)
  994.   int    id, index, size;
  995.   Byte    *data;
  996. - #endif
  997.   {
  998.       ListPtr    list;
  999.       int    rtrn;
  1000. --- 1367,1376 ----
  1001. ***************
  1002. *** 1422,1428 ****
  1003.   
  1004.       BYTE_COPY((list->current)->data, data, size);
  1005.   
  1006. !     if (list->current == list->first)
  1007.           return(lFIRST);
  1008.       else if (list->current == list->last)
  1009.           return(lLAST);
  1010. --- 1390,1398 ----
  1011.   
  1012.       BYTE_COPY((list->current)->data, data, size);
  1013.   
  1014. !     if (list->n == 1)
  1015. !         return(lLAST);
  1016. !     else if (list->current == list->first)
  1017.           return(lFIRST);
  1018.       else if (list->current == list->last)
  1019.           return(lLAST);
  1020. ***************
  1021. *** 1445,1459 ****
  1022.   ** Return on error:
  1023.   **    lUNKNOWN_ID, lEMPTY_LIST, lWRONG_INDEX
  1024.   */
  1025. - #ifdef ANSI
  1026.   int
  1027. - lUpdIndxNode(int id, int index, Byte *data, int size, int flag)
  1028. - #else
  1029. - int
  1030.   lUpdIndxNode(id, index, data, size, flag)
  1031.   int    id, index, size, flag;
  1032.   Byte    *data;
  1033. - #endif
  1034.   {
  1035.       ListPtr    list;
  1036.       int    rtrn;
  1037. --- 1415,1424 ----
  1038. ***************
  1039. *** 1489,1502 ****
  1040.   ** Return on error:
  1041.   **    lUNKNOWN_ID, lEMPTY_LIST, lWRONG_INDEX
  1042.   */
  1043. - #ifdef ANSI
  1044.   int
  1045. - lDelIndxNode(int id, int index)
  1046. - #else
  1047. - int
  1048.   lDelIndxNode(id, index)
  1049.   int    id, index;
  1050. - #endif
  1051.   {
  1052.       int    rtrn;
  1053.   
  1054. --- 1454,1462 ----
  1055. ***************
  1056. *** 1510,1523 ****
  1057.   /* ---------- static local functions ---------------------------------------- */
  1058.   
  1059.   /* get address of list data */
  1060. - #ifdef ANSI
  1061.   static ListPtr
  1062. - getAddress(int id)
  1063. - #else
  1064. - static ListPtr
  1065.   getAddress(id)
  1066.   int    id;
  1067. - #endif
  1068.   {
  1069.       ListPtr    list;
  1070.   
  1071. --- 1470,1478 ----
  1072. ***************
  1073. *** 1535,1549 ****
  1074.   }
  1075.   
  1076.   /* delete nodes of a linked list */
  1077. - #ifdef ANSI
  1078.   static void
  1079. - delNodes(NodePtr node, int n)
  1080. - #else
  1081. - static void
  1082.   delNodes(node, n)
  1083.   NodePtr    node;
  1084.   int    n;
  1085. - #endif
  1086.   {
  1087.       NodePtr    nxt;
  1088.       int    i;
  1089. --- 1490,1499 ----
  1090. ***************
  1091. *** 1557,1570 ****
  1092.   }
  1093.   
  1094.   /* delete info about linked list */
  1095. - #ifdef ANSI
  1096.   static void
  1097. - delListInfo(ListPtr list)
  1098. - #else
  1099. - static void
  1100.   delListInfo(list)
  1101.   ListPtr    list;
  1102. - #endif
  1103.   {
  1104.       ListPtr    nxt;
  1105.   
  1106. --- 1507,1515 ----
  1107. ***************
  1108. *** 1576,1592 ****
  1109.   }
  1110.   
  1111.   /* print error message in lERROR_FILE */
  1112. - #ifdef ANSI
  1113.   static void
  1114. - lError(char *str, int code, int int1, int int2, char *str1)
  1115. - #else
  1116. - static void
  1117.   lError(str, code, int1, int2, str1)
  1118.   char    *str, *str1;
  1119.   int    code, int1, int2;
  1120. - #endif
  1121.   {
  1122. - #ifndef MSDOS
  1123.       char    mess[60];
  1124.       FILE    *fpError, *fopen();
  1125.   
  1126. --- 1521,1531 ----
  1127. ***************
  1128. *** 1660,1680 ****
  1129.           fprintf(stderr, "Can't open error-file '%s'\n", lERROR_FILE);
  1130.           fprintf(stderr, "Error, '%s': %s\n", str, mess);
  1131.       } else {
  1132. !         fprintf(fpError, "Error, '%s': %s\n", str, mess);
  1133.           fclose(fpError);
  1134.       }
  1135. - #endif
  1136.   }
  1137.   
  1138. - #ifdef ANSI
  1139.   static int
  1140. - setWhchNode(int id, int which, char *fname)
  1141. - #else
  1142. - static int
  1143.   setWhchNode(id, which, fname)
  1144.   int    id, which;
  1145.   char    *fname;
  1146. - #endif
  1147.   {
  1148.       ListPtr        list;
  1149.       static int    set[] = { lFIRST, lNEXT, lCURRENT, lPREVIOUS, lLAST };
  1150. --- 1599,1613 ----
  1151.           fprintf(stderr, "Can't open error-file '%s'\n", lERROR_FILE);
  1152.           fprintf(stderr, "Error, '%s': %s\n", str, mess);
  1153.       } else {
  1154. !         fprintf(fpError, "Error in '%s': %s\n", str, mess);
  1155.           fclose(fpError);
  1156.       }
  1157.   }
  1158.   
  1159.   static int
  1160.   setWhchNode(id, which, fname)
  1161.   int    id, which;
  1162.   char    *fname;
  1163.   {
  1164.       ListPtr        list;
  1165.       static int    set[] = { lFIRST, lNEXT, lCURRENT, lPREVIOUS, lLAST };
  1166. ***************
  1167. *** 1726,1740 ****
  1168.       return(lSUCCESS);
  1169.   }
  1170.   
  1171. - #ifdef ANSI
  1172.   static int
  1173. - setIndxNode(int id, int index, char *fname)
  1174. - #else
  1175. - static int
  1176.   setIndxNode(id, index, fname)
  1177.   int    id, index;
  1178.   char    *fname;
  1179. - #endif
  1180.   {
  1181.       ListPtr    list;
  1182.       int    i;
  1183. --- 1659,1668 ----
  1184. ***************
  1185. *** 1767,1782 ****
  1186.   }
  1187.   
  1188.   /* local function for QUICK sort */
  1189. ! #ifdef ANSI
  1190. ! static int
  1191. ! partition(NodePtr *array, int order, Func func, int lb, int ub, int *pj)
  1192. ! #else
  1193. ! static int
  1194.   partition(array, order, func, lb, ub, pj)
  1195.   NodePtr    *array;
  1196.   int    order, lb, ub, *pj;
  1197.   Func    func;
  1198. - #endif
  1199.   {
  1200.       int    down, up, cmp;
  1201.       NodePtr    temp, a;
  1202. --- 1695,1705 ----
  1203.   }
  1204.   
  1205.   /* local function for QUICK sort */
  1206. ! static void
  1207.   partition(array, order, func, lb, ub, pj)
  1208.   NodePtr    *array;
  1209.   int    order, lb, ub, *pj;
  1210.   Func    func;
  1211.   {
  1212.       int    down, up, cmp;
  1213.       NodePtr    temp, a;
  1214. ***************
  1215. *** 1812,1825 ****
  1216.   }
  1217.   
  1218.   /* local function for QUICK sort */
  1219. - #ifdef ANSI
  1220.   static int
  1221. - stack_empty(int id)
  1222. - #else
  1223. - static int
  1224.   stack_empty(id)
  1225.   int    id;
  1226. - #endif
  1227.   {
  1228.       int    sd, cc, n;
  1229.   
  1230. --- 1735,1743 ----
  1231. *** ../list.h    Tue Apr 20 11:06:14 1993
  1232. --- list.h    Wed May 19 10:08:47 1993
  1233. ***************
  1234. *** 50,59 ****
  1235.   
  1236.   #define    lFOUND        0    /* node found */
  1237.   
  1238. ! #ifdef MSDOS_OR_VAXC
  1239.   #define    lERROR_FILE    "linklist.err"
  1240.   #else
  1241.   #define    lERROR_FILE    "=listError="
  1242.   #endif
  1243.   
  1244.   #ifdef ANSI
  1245. --- 50,63 ----
  1246.   
  1247.   #define    lFOUND        0    /* node found */
  1248.   
  1249. ! #ifdef MSDOS
  1250.   #define    lERROR_FILE    "linklist.err"
  1251.   #else
  1252. + # ifdef VAXC
  1253. + #define    lERROR_FILE    "linklist.err"
  1254. + # else
  1255.   #define    lERROR_FILE    "=listError="
  1256. + # endif
  1257.   #endif
  1258.   
  1259.   #ifdef ANSI
  1260. *** ../sorted.c    Fri Feb 26 11:25:09 1993
  1261. --- sorted.c    Wed May 19 14:09:36 1993
  1262. ***************
  1263. *** 2,10 ****
  1264.   #include    <string.h>
  1265.   #include    "list.h"
  1266.   
  1267. - static void    addPersonSorted(), addPerson();
  1268. - static int    fndNxtPerson(), sortPerson(), compare();
  1269. - 
  1270.   typedef struct person {
  1271.       char    lastname[15];
  1272.       char    firstname[15];
  1273. --- 2,7 ----
  1274. ***************
  1275. *** 11,16 ****
  1276. --- 8,25 ----
  1277.   } Person, *PersonPtr;
  1278.   int    personSz = sizeof(Person);
  1279.   
  1280. + #ifdef ANSI
  1281. + static void    addPerson(int id, char *first, char *last);
  1282. + static void    addPersonSorted(int id, char *first, char *last);
  1283. + static int    compare(PersonPtr p1, PersonPtr p2, int order);
  1284. + static int    fndNxtPerson(char *last, PersonPtr data);
  1285. + static int    sortPerson(int id);
  1286. + #else
  1287. + static void    addPerson(), addPersonSorted();
  1288. + static int    compare(), fndNxtPerson(), sortPerson();
  1289. + #endif
  1290. + 
  1291. + int
  1292.   main()
  1293.   {
  1294.       Person    person;
  1295. *** ../sorttest.c    Mon May  3 11:45:21 1993
  1296. --- sorttest.c    Wed May 19 14:37:07 1993
  1297. ***************
  1298. *** 1,9 ****
  1299.   /* Sort torture test */
  1300.   
  1301.   #include    <stdio.h>
  1302.   #include    <string.h>
  1303.   #include    "list.h"
  1304. - #include    "time.h"
  1305.   
  1306.   typedef struct catalog {
  1307.       char        number[35];
  1308. --- 1,21 ----
  1309.   /* Sort torture test */
  1310.   
  1311. + #ifdef UNIX
  1312. + #include    <malloc.h>
  1313. + #endif
  1314. + 
  1315. + #ifdef    AMIGA
  1316. + #include    <stdlib.h>
  1317. + #endif
  1318. + 
  1319. + #ifdef MSDOS
  1320. + #include    <malloc.h>
  1321. + #endif
  1322. + 
  1323.   #include    <stdio.h>
  1324.   #include    <string.h>
  1325. + #include    <time.h>
  1326.   #include    "list.h"
  1327.   
  1328.   typedef struct catalog {
  1329.       char        number[35];
  1330. ***************
  1331. *** 12,32 ****
  1332.       int        date;
  1333.   } catalog;
  1334.   
  1335.   static int    compare_author();
  1336.   static int    compare_title();
  1337.   static void    load_it();
  1338.   static void    print_some();
  1339.   static time_t    what_time();
  1340.   static void    prRap();
  1341.   
  1342. - #ifdef ANSI
  1343.   static int
  1344. - compare_author(catalog *a, catalog *b)
  1345. - #else
  1346. - static int
  1347.   compare_author(a, b)
  1348.   catalog *a, *b;
  1349. - #endif
  1350.   {
  1351.       int    k;
  1352.   
  1353. --- 24,50 ----
  1354.       int        date;
  1355.   } catalog;
  1356.   
  1357. + #ifdef ANSI
  1358. + static int    compare_author(catalog *a, catalog *b);
  1359. + static int    compare_title(catalog *a, catalog *b, int order);
  1360. + static void    load_it(int id, int num);
  1361. + static void    print_some(int id, int num);
  1362. + static time_t    what_time(void);
  1363. + static void    diff_time(time_t a, time_t b);
  1364. + static void    prRap(int code, catalog *rpprt);
  1365. + #else
  1366.   static int    compare_author();
  1367.   static int    compare_title();
  1368.   static void    load_it();
  1369.   static void    print_some();
  1370.   static time_t    what_time();
  1371. + static void    diff_time();
  1372.   static void    prRap();
  1373. + #endif
  1374.   
  1375.   static int
  1376.   compare_author(a, b)
  1377.   catalog *a, *b;
  1378.   {
  1379.       int    k;
  1380.   
  1381. ***************
  1382. *** 40,54 ****
  1383.           return(l1LT2);
  1384.   }
  1385.   
  1386. - #ifdef ANSI
  1387.   static int
  1388. - compare_title(catalog *a, catalog *b, int order)
  1389. - #else
  1390. - static int
  1391.   compare_title(a, b, order)
  1392.   catalog *a, *b;
  1393.   int order;
  1394. - #endif
  1395.   {
  1396.       int    k;
  1397.   
  1398. --- 58,67 ----
  1399. ***************
  1400. *** 62,76 ****
  1401.           return(l1LT2);
  1402.   }
  1403.   
  1404. - #ifdef ANSI
  1405.   static void
  1406. - load_it(int id, int num)
  1407. - #else
  1408. - static void
  1409.   load_it(id, num)
  1410.   int id;
  1411.   int num;
  1412. - #endif
  1413.   {
  1414.       int    loop, size = sizeof(catalog), code;
  1415.       char    c1, c2, c3, c4, c5, c6, c7, c8;
  1416. --- 75,84 ----
  1417. ***************
  1418. *** 99,113 ****
  1419.       /* printf("Linked List created\n"); */
  1420.   }
  1421.   
  1422. - #ifdef ANSI
  1423.   static void
  1424. - print_some(int id, int num)
  1425. - #else
  1426. - static void
  1427.   print_some(id, num)
  1428.   int id;
  1429.   int num;
  1430. - #endif
  1431.   {
  1432.       int    size = sizeof(catalog), loop;
  1433.       int    code;
  1434. --- 107,116 ----
  1435. ***************
  1436. *** 122,142 ****
  1437.       }
  1438.   }
  1439.   
  1440. ! #ifdef ANSI
  1441. ! static time_t what_time(void)
  1442. ! #else
  1443. ! static time_t what_time()
  1444. ! #endif
  1445.   {
  1446.       return((time_t)time(NULL));
  1447.   }
  1448.   
  1449. ! #ifdef ANSI
  1450. ! static void diff_time(time_t a, time_t b)
  1451. ! #else
  1452. ! static void diff_time(a, b)
  1453.   time_t a, b;
  1454. - #endif
  1455.   {
  1456.       struct tm    *tt;
  1457.       char        buf1[101], buf2[101];
  1458. --- 125,139 ----
  1459.       }
  1460.   }
  1461.   
  1462. ! static time_t
  1463. ! what_time()
  1464.   {
  1465.       return((time_t)time(NULL));
  1466.   }
  1467.   
  1468. ! static void
  1469. ! diff_time(a, b)
  1470.   time_t a, b;
  1471.   {
  1472.       struct tm    *tt;
  1473.       char        buf1[101], buf2[101];
  1474. ***************
  1475. *** 160,165 ****
  1476. --- 157,163 ----
  1477.       (sec[1] - sec[0] > 0)?(sec[1] - sec[0]) : (sec[0] - sec[1]));
  1478.   }
  1479.   
  1480. + int
  1481.   main()
  1482.   {
  1483.       int    size = sizeof(catalog);
  1484. ***************
  1485. *** 175,181 ****
  1486.       printf("Untouched list\n");
  1487.       print_some(id, 10);
  1488.   
  1489. !     printf("-- lQuickSort --\nlQuickSort DESCENDING by TITLE : ");
  1490.       start = what_time();
  1491.       code = lSort(id, lDESCENDING, lQUICK, compare_title);
  1492.       finish = what_time();
  1493. --- 173,179 ----
  1494.       printf("Untouched list\n");
  1495.       print_some(id, 10);
  1496.   
  1497. !     printf("lQuickSort DESCENDING by TITLE : ");
  1498.       start = what_time();
  1499.       code = lSort(id, lDESCENDING, lQUICK, compare_title);
  1500.       finish = what_time();
  1501. ***************
  1502. *** 213,219 ****
  1503.       printf("Untouched list\n");
  1504.       print_some(id, 10);
  1505.   
  1506. !     printf(" -- lHeapSort -- \nlHeapSort DESCENDING by TITLE : ");
  1507.       start = what_time();
  1508.       code = lSort(id, lDESCENDING, lHEAP, compare_title);
  1509.       finish = what_time();
  1510. --- 211,217 ----
  1511.       printf("Untouched list\n");
  1512.       print_some(id, 10);
  1513.   
  1514. !     printf("lHeapSort DESCENDING by TITLE : ");
  1515.       start = what_time();
  1516.       code = lSort(id, lDESCENDING, lHEAP, compare_title);
  1517.       finish = what_time();
  1518. ***************
  1519. *** 332,343 ****
  1520.   
  1521.   static void
  1522.   prRap(code, rpprt)
  1523. ! int            code;
  1524. ! catalog        *rpprt;
  1525.   {
  1526.       if (code >= 0)
  1527. !         printf("catalog :'%s' '%s' '%s' '%d'\n", rpprt->number, rpprt->title,
  1528. !             rpprt->author, rpprt->date);
  1529.       else
  1530.           printf("Return code = %d\n", code);
  1531.   }
  1532. --- 330,341 ----
  1533.   
  1534.   static void
  1535.   prRap(code, rpprt)
  1536. ! int    code;
  1537. ! catalog    *rpprt;
  1538.   {
  1539.       if (code >= 0)
  1540. !         printf("catalog :'%s'\t'%s'\t'%s'\t'%d'\n", rpprt->number,
  1541. !             rpprt->title, rpprt->author, rpprt->date);
  1542.       else
  1543.           printf("Return code = %d\n", code);
  1544.   }
  1545. *** ../Doc/Intro.3    Fri Feb 26 10:56:12 1993
  1546. --- Doc/Intro.3    Thu May 27 12:01:52 1993
  1547. ***************
  1548. *** 1,4 ****
  1549. - '.so tmac.clman
  1550.   .TH "Intro"
  1551.   .IX Intro
  1552.   .SH NAME
  1553. --- 1,3 ----
  1554. ***************
  1555. *** 78,83 ****
  1556. --- 77,86 ----
  1557.   .SH EXAMPLE
  1558.   .if t .ta 0.3i 0.6i 0.9i 1.2i 2.2i 3.2i 4.2i 4.5i 4.8i
  1559.   .nf
  1560. + #ifdef    AMIGA
  1561. + #include        <string.h>
  1562. + #endif
  1563. + 
  1564.   #include        <stdio.h>
  1565.   #include        "list.h"
  1566.   
  1567. ***************
  1568. *** 88,96 ****
  1569.   } Rapport;
  1570.   int    rapSz = sizeof(Rapport);
  1571.   
  1572.   static void    insRap(), prRapAll(), prRap();
  1573. ! static int        search(), compare();
  1574.   
  1575.   main()
  1576.   {
  1577.       int            id, code, search_date;
  1578. --- 91,109 ----
  1579.   } Rapport;
  1580.   int    rapSz = sizeof(Rapport);
  1581.   
  1582. + #ifdef ANSI
  1583. + static void    insRap(int id, int where, int flag, char *title, char *author,
  1584. +                 int date);
  1585. + static void    prRapAll(int id);
  1586. + static void    prRap(int code, Rapport *rpprt);
  1587. + static int    search(int *date, Rapport *rpprt);
  1588. + static int    compare(Rapport *data1, Rapport *data2);
  1589. + #else
  1590.   static void    insRap(), prRapAll(), prRap();
  1591. ! static int    search(), compare();
  1592. ! #endif
  1593.   
  1594. + int
  1595.   main()
  1596.   {
  1597.       int            id, code, search_date;
  1598. ***************
  1599. *** 102,111 ****
  1600.       insRap(id, lFIRST, 2, "Book 2", "More People", 890130);
  1601.       insRap(id, lLAST, 1, "Book 3", "Lots of People", 890131);
  1602.   
  1603. !     fprintf(stdout, "lGetNode\n");
  1604.       prRapAll(id);
  1605.   
  1606. !     fprintf(stdout, "lGetIndxNode\n");
  1607.       code = lGetIndxNode(id, 4, &rap, rapSz);
  1608.       prRap(code, &rap);
  1609.       code = lGetIndxNode(id, 2, &rap, rapSz);
  1610. --- 115,124 ----
  1611.       insRap(id, lFIRST, 2, "Book 2", "More People", 890130);
  1612.       insRap(id, lLAST, 1, "Book 3", "Lots of People", 890131);
  1613.   
  1614. !     fprintf(stdout, "lGetNode\\n");
  1615.       prRapAll(id);
  1616.   
  1617. !     fprintf(stdout, "lGetIndxNode\\n");
  1618.       code = lGetIndxNode(id, 4, &rap, rapSz);
  1619.       prRap(code, &rap);
  1620.       code = lGetIndxNode(id, 2, &rap, rapSz);
  1621. ***************
  1622. *** 115,121 ****
  1623.       code = lGetIndxNode(id, 3, &rap, rapSz);
  1624.       prRap(code, &rap);
  1625.   
  1626. !     fprintf(stdout, "lFndNode\n");
  1627.       search_date = 890129;
  1628.       code = lFndNode(id, lFIRST, search, &search_date, &rap, rapSz);
  1629.       prRap(code, &rap);
  1630. --- 128,134 ----
  1631.       code = lGetIndxNode(id, 3, &rap, rapSz);
  1632.       prRap(code, &rap);
  1633.   
  1634. !     fprintf(stdout, "lFndNode\\n");
  1635.       search_date = 890129;
  1636.       code = lFndNode(id, lFIRST, search, &search_date, &rap, rapSz);
  1637.       prRap(code, &rap);
  1638. ***************
  1639. *** 125,142 ****
  1640.       prRap(code, &rap);
  1641.   
  1642.       code = lDump(id, "dump");
  1643. !     fprintf(stdout, "lDump : %d\n", code);
  1644.   
  1645.       lDel(id);
  1646.   
  1647.       id = lUndump("dump");
  1648. !     fprintf(stdout, "lUndump : %d\n", id);
  1649.   
  1650.       insRap(id, lFIRST, 4, "Book 4", "The Author", 891127);
  1651.   
  1652.       prRapAll(id);
  1653.   
  1654. !     fprintf(stdout, "lFndFlagNode\n");
  1655.       code = lFndFlagNode(id, lFIRST, 1, &rap, rapSz);
  1656.       prRap(code, &rap);
  1657.       code = lFndFlagNode(id, lNEXT, 1, &rap, rapSz);
  1658. --- 138,155 ----
  1659.       prRap(code, &rap);
  1660.   
  1661.       code = lDump(id, "dump");
  1662. !     fprintf(stdout, "lDump : %d\\n", code);
  1663.   
  1664.       lDel(id);
  1665.   
  1666.       id = lUndump("dump");
  1667. !     fprintf(stdout, "lUndump : %d\\n", id);
  1668.   
  1669.       insRap(id, lFIRST, 4, "Book 4", "The Author", 891127);
  1670.   
  1671.       prRapAll(id);
  1672.   
  1673. !     fprintf(stdout, "lFndFlagNode\\n");
  1674.       code = lFndFlagNode(id, lFIRST, 1, &rap, rapSz);
  1675.       prRap(code, &rap);
  1676.       code = lFndFlagNode(id, lNEXT, 1, &rap, rapSz);
  1677. ***************
  1678. *** 146,159 ****
  1679.       code = lFndFlagNode(id, lFIRST, 7, &rap, rapSz);
  1680.       prRap(code, &rap);
  1681.       
  1682. !     fprintf(stdout, "Untouched list\n");
  1683.       prRapAll(id);
  1684.   
  1685. !     fprintf(stdout, "lSort\n");
  1686.       lSort(id, lDESCENDING, lBUBBLE, compare);
  1687.       prRapAll(id);
  1688.   
  1689. !     fprintf(stdout, "lSort\n");
  1690.       lSort(id, lASCENDING, lHEAP, compare);
  1691.       prRapAll(id);
  1692.   
  1693. --- 159,172 ----
  1694.       code = lFndFlagNode(id, lFIRST, 7, &rap, rapSz);
  1695.       prRap(code, &rap);
  1696.       
  1697. !     fprintf(stdout, "Untouched list\\n");
  1698.       prRapAll(id);
  1699.   
  1700. !     fprintf(stdout, "lSort\\n");
  1701.       lSort(id, lDESCENDING, lBUBBLE, compare);
  1702.       prRapAll(id);
  1703.   
  1704. !     fprintf(stdout, "lSort\\n");
  1705.       lSort(id, lASCENDING, lHEAP, compare);
  1706.       prRapAll(id);
  1707.   
  1708. ***************
  1709. *** 162,169 ****
  1710.   
  1711.   static void
  1712.   insRap(id, where, flag, title, author, date)
  1713. ! int    id, where, flag, date;
  1714. ! char    *title, *author;
  1715.   {
  1716.       int        code;
  1717.       Rapport    rap;
  1718. --- 175,182 ----
  1719.   
  1720.   static void
  1721.   insRap(id, where, flag, title, author, date)
  1722. ! int        id, where, flag, date;
  1723. ! char        *title, *author;
  1724.   {
  1725.       int        code;
  1726.       Rapport    rap;
  1727. ***************
  1728. *** 195,204 ****
  1729.   Rapport        *rpprt;
  1730.   {
  1731.       if (code >= 0)
  1732. !         fprintf(stdout, "Rapport : '%s' '%s' '%d'\n", rpprt->title,
  1733.               rpprt->author, rpprt->date);
  1734.       else
  1735. !         fprintf(stdout, "Return code = %d\n", code);
  1736.   }
  1737.   
  1738.   static int
  1739. --- 208,217 ----
  1740.   Rapport        *rpprt;
  1741.   {
  1742.       if (code >= 0)
  1743. !         fprintf(stdout, "Rapport : '%s' '%s' '%d'\\n", rpprt->title,
  1744.               rpprt->author, rpprt->date);
  1745.       else
  1746. !         fprintf(stdout, "Return code = %d\\n", code);
  1747.   }
  1748.   
  1749.   static int
  1750. ***************
  1751. *** 226,281 ****
  1752.           return(l1LT2);    /* key1 < key2 */
  1753.   }
  1754.   .fi
  1755. - .sp 2
  1756. - This example program produces the following output :
  1757. - .nf
  1758. -     lGetNode
  1759. -     Rapport : 'Book 2' 'More People' '890130'
  1760. -     Rapport : 'Book 1' 'People' '890129'
  1761. -     Rapport : 'Book 3' 'Lots of People' '890131'
  1762. -     Return code = -9
  1763. -     lGetIndxNode
  1764. -     Return code = -13
  1765. -     Rapport : 'Book 1' 'People' '890129'
  1766. -     Return code = -13
  1767. -     Rapport : 'Book 3' 'Lots of People' '890131'
  1768. -     lFndNode
  1769. -     Rapport : 'Book 2' 'More People' '890130'
  1770. -     Rapport : 'Book 3' 'Lots of People' '890131'
  1771. -     Return code = -10
  1772. -     lDump : 0
  1773. -     lUndump : 1
  1774. -     Rapport : 'Book 4' 'The Author' '891127'
  1775. -     Rapport : 'Book 2' 'More People' '890130'
  1776. -     Rapport : 'Book 1' 'People' '890129'
  1777. -     Rapport : 'Book 3' 'Lots of People' '890131'
  1778. -     Return code = -9
  1779. -     lFndFlagNode
  1780. -     Rapport : 'Book 1' 'People' '890129'
  1781. -     Rapport : 'Book 3' 'Lots of People' '890131'
  1782. -     Rapport : 'Book 2' 'More People' '890130'
  1783. -     Return code = -10
  1784. -     Untouched list
  1785. -     Rapport : 'Book 4' 'The Author' '891127'
  1786. -     Rapport : 'Book 2' 'More People' '890130'
  1787. -     Rapport : 'Book 1' 'People' '890129'
  1788. -     Rapport : 'Book 3' 'Lots of People' '890131'
  1789. -     Return code = -9
  1790. -     lSort
  1791. -     Rapport : 'Book 4' 'The Author' '891127'
  1792. -     Rapport : 'Book 1' 'People' '890129'
  1793. -     Rapport : 'Book 2' 'More People' '890130'
  1794. -     Rapport : 'Book 3' 'Lots of People' '890131'
  1795. -     Return code = -9
  1796. -     lSort
  1797. -     Rapport : 'Book 3' 'Lots of People' '890131'
  1798. -     Rapport : 'Book 2' 'More People' '890130'
  1799. -     Rapport : 'Book 1' 'People' '890129'
  1800. -     Rapport : 'Book 4' 'The Author' '891127'
  1801. -     Return code = -9
  1802. - .fi
  1803.   .SH VERSION
  1804. ! Generic Linked List 0.8, March 1993.
  1805.   .SH PUBLIC DOMAIN
  1806.   The Generic Linked List package is in the public domain. If you have
  1807.   any comments, suggestions, or find any bugs, or make any changes you'd
  1808. --- 239,246 ----
  1809.           return(l1LT2);    /* key1 < key2 */
  1810.   }
  1811.   .fi
  1812.   .SH VERSION
  1813. ! Generic Linked List 0.9, May 1993.
  1814.   .SH PUBLIC DOMAIN
  1815.   The Generic Linked List package is in the public domain. If you have
  1816.   any comments, suggestions, or find any bugs, or make any changes you'd
  1817. *** ../Doc/lDef.3    Fri Feb 26 10:30:43 1993
  1818. --- Doc/lDef.3    Thu May 27 12:01:53 1993
  1819. ***************
  1820. *** 27,32 ****
  1821. --- 27,33 ----
  1822.       lDOUBLY    doubly linked list, each node points to the previous and
  1823.           the next node
  1824.   .fi
  1825. + .sp 1
  1826.   \fIcc\fP :
  1827.   .nf
  1828.       lCHAIN    chain linked list, last node has a NULL-pointer
  1829. *** ../Doc/lFndFlagNode.3    Fri Feb 26 10:38:09 1993
  1830. --- Doc/lFndFlagNode.3    Thu May 27 12:01:53 1993
  1831. ***************
  1832. *** 5,11 ****
  1833.   lFndFlagNode - Get node by flag.
  1834.   .SH SYNOPSIS
  1835.   int
  1836. ! .BR "lFndFlagNode" "(id, from, flag, data, size)"
  1837.   .br
  1838.   .RT
  1839.   .RP
  1840. --- 5,11 ----
  1841.   lFndFlagNode - Get node by flag.
  1842.   .SH SYNOPSIS
  1843.   int
  1844. ! .BR "lFndFlagNode" "(id, which, flag, data, size)"
  1845.   .br
  1846.   .RT
  1847.   .RP
  1848. ***************
  1849. *** 12,18 ****
  1850.   In    int    id    identifier of linked list
  1851.   .br
  1852.   .RP
  1853. ! In    int    from    from where must be searched
  1854.   .br
  1855.   .RP
  1856.   In    int    flag    flag of node which must be retrieved
  1857. --- 12,18 ----
  1858.   In    int    id    identifier of linked list
  1859.   .br
  1860.   .RP
  1861. ! In    int    which    from which node must be searched and in which direction
  1862.   .br
  1863.   .RP
  1864.   In    int    flag    flag of node which must be retrieved
  1865. ***************
  1866. *** 25,47 ****
  1867.   .DT
  1868.   .SH DESCRIPTION
  1869.   \fBlFndFlagNode\fP searches a 'flagged' node from the linked list. From
  1870. ! where the node must be searched can be specified by \fIfrom\fP. A node
  1871. ! can be searched forward from the beginning of the list or from the
  1872. ! current node and backward from the current node or from the end of the
  1873. ! list.
  1874.   .br
  1875.   Backward searching is only possible for doubly linked list.
  1876.   .br
  1877.   When the found node is the first or the last node, the return code will
  1878.   have the value lFIRST or lLAST, otherwise lFOUND.
  1879.   .SH PARAMETER DEFINITIONS
  1880.   .if t .ta 0.2i 1.5i
  1881. ! \fIfrom\fP :
  1882.   .nf
  1883. !     lFIRST    search forward from first node
  1884. !     lPREVIOUS    search backward from previous node
  1885. !     lNEXT    search forward from next node
  1886. !     lLAST    search backward from last node
  1887.   .fi
  1888.   .SH RETURN CODES
  1889.   .nf
  1890. --- 25,51 ----
  1891.   .DT
  1892.   .SH DESCRIPTION
  1893.   \fBlFndFlagNode\fP searches a 'flagged' node from the linked list. From
  1894. ! which node the searching must start and in which direction must be
  1895. ! searched can be specified by \fIwhich\fP. A node can be searched forward
  1896. ! from the beginning of the list (lFIRST) or from the current node (lNEXT)
  1897. ! and backward from the end of the list (lLAST) or from the current node
  1898. ! (lPREVIOUS).
  1899.   .br
  1900.   Backward searching is only possible for doubly linked list.
  1901.   .br
  1902.   When the found node is the first or the last node, the return code will
  1903.   have the value lFIRST or lLAST, otherwise lFOUND.
  1904. + When the linked list contains only one node, the return code will have
  1905. + the value lFIRST, when searching backward, and the value lLAST, when
  1906. + searching forward.
  1907.   .SH PARAMETER DEFINITIONS
  1908.   .if t .ta 0.2i 1.5i
  1909. ! \fIwhich\fP :
  1910.   .nf
  1911. !     lFIRST    search forward starting from the first node
  1912. !     lNEXT    search forward starting from the next node
  1913. !     lLAST    search backward starting from the last node
  1914. !     lPREVIOUS    search backward starting from the previous node
  1915.   .fi
  1916.   .SH RETURN CODES
  1917.   .nf
  1918. ***************
  1919. *** 48,54 ****
  1920.   Return on success :
  1921.       lFOUND, lFIRST, lLAST, lNOT_FOUND
  1922.   Return on error :
  1923. !     lUNKNOWN_ID, lEMPTY_LIST, lWRONG_FROM, lSIZE_NE
  1924.   .fi
  1925.   .SH AUTHOR
  1926.   Anita Eijs (TNO - Bouw - BouwInformatica)
  1927. --- 52,58 ----
  1928.   Return on success :
  1929.       lFOUND, lFIRST, lLAST, lNOT_FOUND
  1930.   Return on error :
  1931. !     lUNKNOWN_ID, lEMPTY_LIST, lWRONG_WHICH, lSIZE_NE
  1932.   .fi
  1933.   .SH AUTHOR
  1934.   Anita Eijs (TNO - Bouw - BouwInformatica)
  1935. *** ../Doc/lFndNode.3    Fri Feb 26 10:47:50 1993
  1936. --- Doc/lFndNode.3    Thu May 27 12:01:53 1993
  1937. ***************
  1938. *** 5,11 ****
  1939.   lFndNode - Find node.
  1940.   .SH SYNOPSIS
  1941.   int
  1942. ! .BR "lFndNode" "(id, from, func, ptr, data, size)"
  1943.   .br
  1944.   .RT
  1945.   .RP
  1946. --- 5,11 ----
  1947.   lFndNode - Find node.
  1948.   .SH SYNOPSIS
  1949.   int
  1950. ! .BR "lFndNode" "(id, which, func, ptr, data, size)"
  1951.   .br
  1952.   .RT
  1953.   .RP
  1954. ***************
  1955. *** 12,18 ****
  1956.   In    int    id    identifier of linked list
  1957.   .br
  1958.   .RP
  1959. ! In    int    from    from where must be searched
  1960.   .br
  1961.   .RP
  1962.   In    int    (*func)()    function for checking the data on conditions
  1963. --- 12,18 ----
  1964.   In    int    id    identifier of linked list
  1965.   .br
  1966.   .RP
  1967. ! In    int    which    from which node must be searched and in which direction
  1968.   .br
  1969.   .RP
  1970.   In    int    (*func)()    function for checking the data on conditions
  1971. ***************
  1972. *** 28,55 ****
  1973.   .DT
  1974.   .SH DESCRIPTION
  1975.   \fBlFndNode\fP searches a node from the linked list, using the user
  1976. ! defined serach function \fIfunc\fP, which checks the data of a node
  1977.   on conditions. This function must have two parameters, a pointer to
  1978.   the data to compare with and a pointer to the data of a node. The
  1979.   possible return values are lFOUND or lNOT_FOUND. See the introduction
  1980.   of Generic Linked List for an example of such a search function. From
  1981. ! where the node must be searched can be specified by \fIfrom\fP. A node
  1982. ! can be searched forward from the beginning of the list or from the
  1983. ! current node and backward from the current node or from the end of the
  1984. ! list.
  1985.   .br
  1986.   Backward searching is only possible for doubly linked list.
  1987.   .br
  1988.   When the found node is the first or the last node, the return code will
  1989.   have the value lFIRST or lLAST, otherwise lFOUND.
  1990.   .SH PARAMETER DEFINITIONS
  1991.   .if t .ta 0.2i 1.5i
  1992. ! \fIfrom\fP :
  1993.   .nf
  1994. !     lFIRST    search forward from first node
  1995. !     lPREVIOUS    search backward from previous node
  1996. !     lNEXT    search forward from next node
  1997. !     lLAST    search backward from last node
  1998.   .fi
  1999.   .SH RETURN CODES
  2000.   .nf
  2001. --- 28,59 ----
  2002.   .DT
  2003.   .SH DESCRIPTION
  2004.   \fBlFndNode\fP searches a node from the linked list, using the user
  2005. ! defined search function \fIfunc\fP, which checks the data of a node
  2006.   on conditions. This function must have two parameters, a pointer to
  2007.   the data to compare with and a pointer to the data of a node. The
  2008.   possible return values are lFOUND or lNOT_FOUND. See the introduction
  2009.   of Generic Linked List for an example of such a search function. From
  2010. ! which node the searching must start and in which direction must be
  2011. ! searched can be specified by \fIwhich\fP. A node can be searched
  2012. ! forward from the beginning of the list (lFIRST) or from the current
  2013. ! node (lNEXT) and backward from the end of the list (lLAST) or from
  2014. ! the current node (lPREVIOUS).
  2015.   .br
  2016.   Backward searching is only possible for doubly linked list.
  2017.   .br
  2018.   When the found node is the first or the last node, the return code will
  2019.   have the value lFIRST or lLAST, otherwise lFOUND.
  2020. + When the linked list contains only one node, the return code will have
  2021. + the value lFIRST, when searching backward, and the value lLAST, when
  2022. + searching forward.
  2023.   .SH PARAMETER DEFINITIONS
  2024.   .if t .ta 0.2i 1.5i
  2025. ! \fIwhich\fP :
  2026.   .nf
  2027. !     lFIRST    search forward starting from the first node
  2028. !     lNEXT    search forward starting from the next node
  2029. !     lLAST    search backward starting from the last node
  2030. !     lPREVIOUS    search backward starting from the previous node
  2031.   .fi
  2032.   .SH RETURN CODES
  2033.   .nf
  2034. ***************
  2035. *** 58,64 ****
  2036.   Return on error :
  2037.   .fi
  2038.   .in +0.2i
  2039. ! lUNKNOWN_ID, lEMPTY_LIST, lWRONG_FROM, lUNKNOWN_FUNC, lNOT_DOUBLY
  2040. ! .in 10.2i
  2041.   .SH AUTHOR
  2042.   Anita Eijs (TNO - Bouw - BouwInformatica)
  2043. --- 62,68 ----
  2044.   Return on error :
  2045.   .fi
  2046.   .in +0.2i
  2047. ! lUNKNOWN_ID, lEMPTY_LIST, lWRONG_WHICH, lNOT_DOUBLY, lUNKNOWN_FUNC
  2048. ! .in -0.2i
  2049.   .SH AUTHOR
  2050.   Anita Eijs (TNO - Bouw - BouwInformatica)
  2051. *** ../Doc/lGetNode.3    Fri Feb 26 10:43:42 1993
  2052. --- Doc/lGetNode.3    Thu May 27 12:01:53 1993
  2053. ***************
  2054. *** 29,34 ****
  2055. --- 29,37 ----
  2056.   When the retrieved node is the first or the last node, the return code
  2057.   will have the value lFIRST or lLAST. For the other nodes the routine
  2058.   returns lSUCCESS.
  2059. + When the linked list contains only one node, the return code will have
  2060. + the value lFIRST, when retrieving backward, and the value lLAST, when
  2061. + retrieving forward.
  2062.   .SH PARAMETER DEFINITIONS
  2063.   .if t .ta 0.2i 1.5i
  2064.   \fIwhich\fP :
  2065. ***************
  2066. *** 45,52 ****
  2067.       lSUCCESS, lFIRST, lLAST
  2068.   Return on error :
  2069.   .fi
  2070. ! .in +02.i
  2071. ! lUNKNOWN_ID, lEMPTY_LIST, lWRONG_WHICH, lEOL, lNOT_DOUBLY, lSIZE_NE
  2072. ! .in -02.i
  2073.   .SH AUTHOR
  2074.   Anita Eijs (TNO - Bouw - BouwInformatica)
  2075. --- 48,55 ----
  2076.       lSUCCESS, lFIRST, lLAST
  2077.   Return on error :
  2078.   .fi
  2079. ! .in +0.2i
  2080. ! lUNKNOWN_ID, lEMPTY_LIST, lWRONG_WHICH, lEOL, lSIZE_NE, lNOT_DOUBLY
  2081. ! .in -0.2i
  2082.   .SH AUTHOR
  2083.   Anita Eijs (TNO - Bouw - BouwInformatica)
  2084. *** ../Doc/lInfoNode.3    Fri Feb 26 10:44:07 1993
  2085. --- Doc/lInfoNode.3    Thu May 27 12:01:53 1993
  2086. ***************
  2087. *** 44,50 ****
  2088.   Return on error :
  2089.   .fi
  2090.   .in +0.2i
  2091. ! lUNKNOWN_ID, lEMPTY_LIST, lWRONG_WHICH, lEOL, lNOT_DOUBLY
  2092.   .in -0.2i
  2093.   .SH AUTHOR
  2094.   Anita Eijs (TNO - Bouw - BouwInformatica)
  2095. --- 44,50 ----
  2096.   Return on error :
  2097.   .fi
  2098.   .in +0.2i
  2099. ! lUNKNOWN_ID, lEMPTY_LIST, lWRONG_WHICH, lNOT_DOUBLY, lEOL
  2100.   .in -0.2i
  2101.   .SH AUTHOR
  2102.   Anita Eijs (TNO - Bouw - BouwInformatica)
  2103. *** ../Doc/lSort.3    Mon Apr 19 13:49:00 1993
  2104. --- Doc/lSort.3    Thu May 27 12:01:53 1993
  2105. ***************
  2106. *** 15,21 ****
  2107.   .RP
  2108.   In    int    theory    sorting theory
  2109.   .RP
  2110. ! In    int    (*func)()    function for comparing the data of 2 nodes
  2111.   .DT
  2112.   .SH DESCRIPTION
  2113.   \fBlSort\fP sorts a linked list in the specified \fIorder\fP, using
  2114. --- 15,21 ----
  2115.   .RP
  2116.   In    int    theory    sorting theory
  2117.   .RP
  2118. ! In    int    (*func)()    function for comparing the data of two nodes
  2119.   .DT
  2120.   .SH DESCRIPTION
  2121.   \fBlSort\fP sorts a linked list in the specified \fIorder\fP, using
  2122. ***************
  2123. *** 31,43 ****
  2124.       lASCENDING    'a', 'b', 'c', ...
  2125.       lDESCENDING    'z', 'y', 'x', ...
  2126.   .fi
  2127.   \fItheory\fP :
  2128.   .nf
  2129. !     lBUBBLE    bubble sorting algorithm ...
  2130. !     lHEAP    heap sorting algorithm ...
  2131. !     lINSERT    insert sorting algorithm ...
  2132. !     lQUICK    quick sorting algorithm ...
  2133. !     lSELECTION    selection sorting algorithm ...
  2134.   .fi
  2135.   .SH RETURN CODES
  2136.   .nf
  2137. --- 31,44 ----
  2138.       lASCENDING    'a', 'b', 'c', ...
  2139.       lDESCENDING    'z', 'y', 'x', ...
  2140.   .fi
  2141. + .sp 1
  2142.   \fItheory\fP :
  2143.   .nf
  2144. !     lBUBBLE    bubble sorting algorithm
  2145. !     lHEAP    heap sorting algorithm
  2146. !     lINSERT    insert sorting algorithm
  2147. !     lQUICK    quick sorting algorithm
  2148. !     lSELECTION    selection sorting algorithm
  2149.   .fi
  2150.   .SH RETURN CODES
  2151.   .nf
  2152.